const ws = uniCloud.webSocketServer();
const db = uniCloud.databaseForJQL()
const _ = db.command;
const Notification = require('Notification');

const uniPush = uniCloud.getPushManager({
	appId: "__UNI__180DEE6"
})

//连接时
exports.onWebsocketConnection = async function(event, context) {

	try {
		console.log('连接成功event', JSON.stringify(event), '连接成功的context', context);
		const online = await updateUserOnline(event);
		console.log('在线状态存储情况', online);

	} catch (e) {
		console.error("连线更新在线用户表失败------", e);
		return {
			success: false,
			errorMsg: e
		}
	}
};

// 收到信息时
exports.onWebsocketMessage = async function(event, context) {

	const revEvent = JSON.parse(event.payload)
	console.log('收到消息', JSON.stringify(event));
	if (revEvent.webSocketType === 'msg') {
		sendMessage(event) //这是对话请求 	

	}

};

// 断开连接时
exports.onWebsocketDisConnection = async function(event, context) {
	console.log("云函数Websocket断开连接", event, context);
	try {
		const offLine = await db.collection('linli-user').where({
			connectionId: event.connectionId
		}).update({
			connectionId: null,
		});
		return {
			success: "联线断开，用户表在线状态删除成功",
		};
	} catch (e) {
		console.error("联线断开，用户表在线状态删除失败", e);
		return {
			success: "联线断开，用户表在线状态删除失败",
			error: e.message
		};
	}
};

// 错误断联时
exports.onWebsocketError = async function(event, context) {
	console.log("云函数Websocket连接错误", event, context);
	try {
		const offLine = await db.collection('linli-user').where({
			connectionId: event.connectionId
		}).update({
			connectionId: null,

		});
		return {
			success: "云函数Websocket连接错误，更新在线用户表成功",
		};
	} catch (e) {
		console.error("云函数Websocket连接错误，更新在线用户表失败", e);
		return {
			success: "云函数Websocket连接错误，更新在线用户表失败",
			error: e.message
		};
	}
};



// 连接时——更新在线用户表
async function updateUserOnline(event) {
	try {
		// 1. 严格校验参数（关键！避免无效查询）
		const {
			userTel
		} = event.query || {}; // 解构并默认空对象，避免event.query为undefined时报错
		const {
			connectionId
		} = event || {};

		if (!userTel || typeof userTel !== 'string' || userTel.trim() === '') {
			throw new Error('参数错误：缺少有效的userTel（电话号码）');
		}
		if (!connectionId || typeof connectionId !== 'string') {
			throw new Error('参数错误：缺少有效的connectionId（连接标识）');
		}

		console.log("上线电话号码：", userTel);
		console.log("当前连接ID：", connectionId);

		// 2. 执行数据库更新
		const res = await db.collection('linli-user').where({
			userTel: userTel.trim() // 去除空格，避免格式问题（如手机号带空格导致匹配失败）
		}).update({
			connectionId: connectionId,
			lastLoginTime: Date.now(),
			online: true // 建议新增online字段标识在线状态，方便后续查询
		});

		console.log("在线状态更新结果：", res);

		// 3. 判断更新是否生效（处理userTel不存在的情况）
		if (res.updated === 0) {
			throw new Error(`更新失败：未找到userTel为${userTel}的用户`);
		}

		return {
			success: true,
			message: '在线状态更新成功'
		};

	} catch (e) {
		// 正确传递原始错误，保留完整堆栈信息
		console.error('更新在线用户表失败（详细错误）：', e); // 先打印原始错误
		// 用cause传递原始错误（现代环境支持），同时在消息中补充细节
		throw new Error(`上线更新用户表错误：${e.message}`, {
			cause: e
		});
	}
}

/**
 * 工具函数：过滤在线用户的 connectionId 并去重
 * @param {Array} userList - 用户列表（包含在线状态和 connectionId）
 * @returns {Array} 去重后的在线 connectionId 数组
 */
function filterAndDeduplicateConnections(userList) {
	console.log('2222222222222222222222222',userList);
	// 1. 过滤有效在线用户（isOnline 为 true 且有 connectionId）
	const validConnections = (userList || []).filter(item =>
		item.connectionId && item.connectionId.trim() !== ''
	).map(item => item.connectionId.trim()); // 去除空格，避免隐性重复
     
	// 2. 用 Set 去重，再转回数组
	return [...new Set(validConnections)];
}

/**
 * 工具函数：过滤离线用户的 push_clientid 并去重
 * @param {Array} userList - 用户列表（包含在线状态和 push_clientid）
 * @returns {Array} 去重后的离线 push_clientid 数组
 */
function filterAndDeduplicatePushes(userList) {
	// 1. 过滤有效离线用户（isOnline 为 false 且有有效 push_clientid）
	const validPushes = (userList || []).filter(item =>
		!item?.isOnline &&
		typeof item?.push_clientid === 'string' &&
		item.push_clientid.trim() !== ''
	).map(item => item.push_clientid.trim()); // 去除空格，避免隐性重复

	// 2. 用 Set 去重，再转回数组
	return [...new Set(validPushes)];
}

/**
 * 根据消息类型获取发送目标的 connectionIds 和 push_clientids
 * @param {Object} message - 消息对象（包含 targetType、location 等信息）
 * @param {Object} event - 事件对象（包含发送者 connectionId 等信息）
 * @returns {Object} { success, connectionIds, push_clientids, error }
 */
async function getSendMsgIds(message, event) {

	// 基础校验：检查 targetType 是否存在
	if (!message?.toTarget?.targetType) {
		return {
			success: false,
			error: '缺少 targetType 参数'
		};
	}

	try {
		switch (message.toTarget.targetType) {
			case '1': // 公聊（附近用户，前端已处理包含自己，仅需去重）
				// 1. 校验接收距离
				const radius = Math.round((message.receiveDistance || 0) / 100);
				if (radius <= 0) {
					return {
						success: false,
						error: '无效的接收距离（需大于0）'
					};
				}

				// 2. 获取附近用户信息（已包含发送者自己）
				const result = await getNearbyInfo(message.location, radius);
	
				const userList = result.data || []; // 原始用户列表（含发送者）

				// 3. 过滤并去重在线 connectionIds 和离线 push_clientids
				return {
					success: true,
						connectionIds: filterAndDeduplicateConnections(userList),
						push_clientids: filterAndDeduplicatePushes(userList)
				};

			case '2': // 群聊（需去重）
				// 1. 校验群 ID
				if (!message.toTarget.targetId) {
					return {
						success: false,
						error: '缺少群聊 targetId'
					};
				}

				// 2. 查询群信息，获取群成员 userId
				const groupRes = await db.collection('Group').where({
					groupId: message.toTarget.targetId
				}).get();
				const groupData = groupRes?.data || [];

				// 3. 提取并去重群成员 userId（过滤无效值）
				const members = [...new Set(
					groupData.flatMap(item =>
						(item?.groupUser || []).map(user => user?.userId).filter(Boolean)
					)
				)];

				// 4. 无成员时直接返回空列表
				if (members.length === 0) {
					return {
						success: true,
						connectionIds: [],
						push_clientids: []
					};
				}

				// 5. 查询群成员的在线状态和推送信息
				const memberInfoRes = await db.collection('linli-user').where({
					userId: _.in(members)
				}).get();
				const memberList = memberInfoRes?.data || [];

				// 6. 过滤并去重
				return {
					success: true,
						connectionIds: filterAndDeduplicateConnections(memberList),
						push_clientids: filterAndDeduplicatePushes(memberList)
				};

			case '3': // 私聊（包含发送者自己，需去重）
				// 1. 校验目标用户 ID
				console.log("收到私聊信息。。。。。。。。。", );
				const targetUserId = message.toTarget.targetId;
				if (!targetUserId) {
					return {
						success: false,
						error: '缺少私聊 targetId（目标用户 ID）'
					};
				}

				// 2. 查询目标用户的在线状态和连接信息
				const targetUserRes = await db.collection('linli-user')
					.where({
						userId: _.eq(targetUserId)
					})
					.field({
						connectionId: true,
						push_clientid: true,

					})
					.get();
				const targetUser = targetUserRes?.data?.[0] || {};

				// 3. 构造基础连接列表（包含发送者自己，用于判断发送成功）
				const baseConnections = event.connectionId ? [event.connectionId
						.trim()
					] // 发送者的 connectionId
					:
					[];

				// 4. 加入目标用户的 connectionId（若在线且有效）
				if (targetUser.connectionId) {
					baseConnections.push(targetUser.connectionId.trim());
				}

				// 5. 构造基础推送列表（仅目标用户离线时）
				const basePushes = [];
				if (!targetUser.connectionId && typeof targetUser.push_clientid === 'string' && targetUser
					.push_clientid
					.trim() !== '') {
					basePushes.push(targetUser.push_clientid.trim());
				}

				// 6. 去重后返回
				return {
					success: true,
						connectionIds: [...new Set(baseConnections)], // 去重发送者+目标用户
						push_clientids: [...new Set(basePushes)] // 去重目标用户推送 ID
				};

			default:
				return {
					success: false, error: `未知的 targetType: ${message.toTarget.targetType}`
				};
		}
	} catch (error) {
		console.error('获取发送目标 ID 失败:', error);
		return {
			success: false,
			error: error.message || '获取发送目标信息时发生错误'
		};
	}
}
//收到消息存到消息库，pubilc/group/person
async function saveMessageToDB(message, event) {
	const upData = {
		sendUserId: message.sendUserId,
		userTel: message.userTel,
		content: message.content,
		location: new db.Geo.Point(message.location.longitude, message.location.latitude),
		timestamp: message.timestamp,
		nicName: message.nicName,
		nicPic: message.nicPic,
		messageType: message.messageType,
		toTarget: message.toTarget,
		connectionId: event.connectionId,
		receiveDistance: message.receiveDistance,
		grid: message.grid
	}
	let dbname = "";
	try {
		if (message.toTarget.targetType === '1') {
			dbname = 'message_public';
		} else if (message.toTarget.targetType === '2') {
			dbname = 'message_group';
		} else if (message.toTarget.targetType === '3') {
			dbname = 'message_person';
		} else {
			throw new Error('未知的targetType');
		}

		const addResult = await db.collection(dbname).add(upData);

		return {
			success: true,
			data: addResult
		};
	} catch (error) {
		console.error('消息插入失败：', error.message);
		return {
			success: false,
			error: error.message
		};
	}
}
//发送信息给符合条件的连线ID
async function sendMessage(event) {
	const message = JSON.parse(event.payload);
	const result = await saveMessageToDB(message, event);
	const msgFormated = {
		code: 0,
		type: "msg",
		data: [{
			...message,
			_id: result.data.id
		}]
	}

	try {
		const sendResult = await getSendMsgIds(message, event);
		console.log("消息接受者", sendResult);

		if (sendResult.success) {
			const newArray = sendResult.connectionIds
			const pushIdList = sendResult.push_clientids
			if (pushIdList.length > 0) {
				const push = await linliaoUniPush(pushIdList, message)

			}
			if (newArray.length > 10) {
				const sendArr = splitArray(newArray)
				sendArr.forEach((arr) => {
					ws.send(arr, JSON.stringify(msgFormated))
				})

			} else {
				try {

					const aa = await ws.send(newArray, JSON.stringify(msgFormated))

				} catch (e) {
					console.error('发送消息出错', e)
				}

			}

		}
	} catch (e) {
		console.error("发送目标客人失败或不在线", e);
	}

}
//将连线ID拆分成100个以内以符合发送不超100个人的限制。
function splitArray(arr) {
	const result = [];
	for (let i = 0; i < arr.length; i += 10) {
		result.push(arr.slice(i, i + 10));
	}
	return result;
}
//当连线时请求信息

//查找群在线成员列表
async function onLineInGroupId(groupId) {
	const dbb = uniCloud.database();

	// 查询群组信息
	const membersData = await dbb.collection('Group').where({
		groupId: groupId
	}).field({
		groupUser: true
	}).get();

	// 检查群组信息是否存在
	if (membersData.data.length === 0 || membersData.data[0].groupUser === null) {
		return [];
	}

	const members = membersData.data[0].groupUser.map(u => u.userId);

	// 查询在线成员的连接ID
	const lineId = await dbb.collection('opendb-poi').where({
		userId: dbb.command.in(members)
	}).field({
		connectionId: true
	}).get();
	const ids = lineId.data.map(item => item.connectionId)
	return ids.filter(id => id !== "offLine") || [];
}


//推送
/**
 * 向多个客户端推送消息（批量处理）
 * @param {Array} clientIds - 客户端ID数组（如['clientId1', 'clientId2']）
 * @param {Object} msg - 消息对象，需包含 nicName 等字段
 * @returns {Promise<Object>} - 包含所有推送结果的对象
 */
// 云函数 - 改进的推送函数
async function linliaoUniPush(clientIds, msg) {
	if (!Array.isArray(clientIds) || clientIds.length === 0) {
		return {
			success: false,
			error: "clientIds必须是非空数组"
		};
	}

	try {
		// 关键：验证CID在uniPush系统中的有效性
		const validationResult = await validateClientIds(clientIds);

		if (!validationResult.validIds || validationResult.validIds.length === 0) {

			return {
				success: true, // 视为成功，只是没有目标
				count: 0,
				message: "没有有效的推送目标"
			};
		}

		const pushParams = {
			title: "新消息提醒",
			content: `${msg.nicName}给您发信息了`,
			push_clientid: validationResult.validIds,
			payload: {
				type: "chat_message",
				sendUserId: msg.sendUserId,
				message: msg.content.text
			},
			platform: ["app-android", "app-ios"],
			request_id: Date.now().toString() // 添加请求ID便于追踪
		};

		const result = await uniPush.sendMessage(pushParams);

		// 处理无效的CID
		if (validationResult.invalidIds.length > 0) {
			await cleanupInvalidClientIds(validationResult.invalidIds);
		}

		if (result && (result.code === 0 || result.errCode === 0)) {
			return {
				success: true,
				count: validationResult.validIds.length,
				detail: result
			};
		} else {
			return {
				success: false,
				error: result?.errMsg || '推送失败',
				detail: result
			};
		}

	} catch (error) {
		console.error('推送异常:', error);
		return {
			success: false,
			error: error.message
		};
	}
}

/**
 * 验证客户端ID在uniPush系统中的有效性
 */
async function validateClientIds(clientIds) {

	const validIds = [];
	const invalidIds = [];

	// 由于uniPush没有直接验证API，我们通过以下方式验证：
	// 1. 检查设备表存在
	// 2. 尝试发送测试推送（可选）

	const db = uniCloud.database();

	for (const cid of clientIds) {
		if (!cid || cid === 'offLine') {
			invalidIds.push(cid);
			continue;
		}

		try {
			// 检查设备表中是否存在
			const deviceRes = await db.collection('opendb-device')
				.where({
					device_id: cid,
					// state: 1 // 正常状态
				})
				.count();

			if (deviceRes.total > 0) {

				validIds.push(cid);
			} else {
				invalidIds.push(cid);

			}
		} catch (error) {
			console.error(`检查CID ${cid} 失败:`, error);
			invalidIds.push(cid);
		}
	}

	return {
		validIds,
		invalidIds
	};
}

exports.main = async (event, context) => {


	if (event.type === 'joinGroup') {
		const jionUser = await getUser(event.userId)
		const content = {
			type: "joinGroup",
			groupId: event.groupId,
			jionUser: jionUser
		}
		const result = await joinGroup(event)
		const ids = await onLineInGroupId(event.groupId)
		console.log('群组在线人员++++++++', ids)
		if (result) {
			ws.send(ids, JSON.stringify(content))
		}
	}
	if (event.type === 'getNearByInfo') {
		const data = await getNearbyInfo(event.location, event.radius)
		return data
	}
	if (event.type === "friend_apply") {
		try {
			const {
				fromUserId,
				toUserId,
				applyMsg
			} = event
			const fromUser = await getUser(fromUserId)
			const noticication = new Notification({
				userId: toUserId,
				type: "friend_apply",
				title: "好友申请",
				content: {
					text: applyMsg,
					
				},
				senderId: fromUserId,
				senderName: fromUser.nicName,
                sendNicPic: fromUser.nicPic.url
			})
			const objectData=noticication.toObject()
			console.log("555555555",objectData);
			const notificationResult = await db.collection('sys_notification').add(
			   objectData
			);

            console.log('2222222222',notificationResult);
			const res = await db.collection('linli-user').where({
				userId:  _.in([toUserId,fromUserId]) 
			}).field({
				connectionId: true,
				push_clientid: true
			}).get()
			     
			if (res.data && res.data.length>0) {
			const msg={ code:0,
			type:"msg",
			data:[	{sendUserId: fromUserId,
						nicPic:fromUser.nicPic,
						nicName:fromUser.nicName,
						content: {
							text:applyMsg,
						},
					    toTarget:{
							targetType:"3",
							targetId:toUserId
						}, // 校验通过后再使用
						messageType: 7,
						timestamp: Date.now(),
						isRead: false,}]
					
					
					};
				
			const connectionIds = res.data
			  .filter(item => item.connectionId != null) // != null 等价于 排除 null 和 undefined
			  .map(item => item.connectionId);
				
		      const sendMsg=await 	ws.send(connectionIds, JSON.stringify(msg))
			  console.log('发送信息回调',sendMsg);
			}
		
		} catch (e) {
			console.error(e);
		}


	}

}

async function getUser(userId) {
	try {
		const res = await db.collection('linli-user').where({
			userId: userId
		}).field({
			userId: true,
			nicName: true,
			userTel: true,
			nicPic: true


		}).get()
		console.log('加入群的用户', res.data[0])
		return res.data[0] || {}
	} catch (e) {
		console.log(e);

	}


}
//加入群
async function joinGroup(event) {
	try {
		const userInfo = {
			userId: event.userId,
			isTemp: true,
			isMuted: false,
			joinTime: new Date(),
			remarkName: ""
		};
		console.log("加入的参数", userInfo);

		const dbb = uniCloud.database();

		// 查询群组信息
		const result = await dbb.collection('Group').where({
			groupId: event.groupId
		}).field({
			groupUser: true
		}).get();
		console.log('值++++++++ ', result)

		if (result.data.length > 0 && result.data[0].groupUser !== null) {
			if (result.data[0].groupUser.some(item => item.userId === userInfo.userId)) {
				return true
			} else {
				await joinToGroup(event, userInfo)
			}

		} else {
			await joinToGroup(event, userInfo)
		}

	} catch (e) {
		console.error(e)
		return false
	}
}
//加入群
async function joinToGroup(event, userInfo) {
	try {
		const dbb = uniCloud.database();
		const resdata = await dbb.collection('Group').where({
			groupId: event.groupId
		}).get();
		console.log('加入群成功了吗？778', resdata);
		const doc = resdata.data[0];
		const groupUser = doc?.groupUser;
		let updateData;
		if (Array.isArray(groupUser)) {
			updateData = {
				groupUser: dbb.command.push(userInfo)
			};
		} else {
			updateData = {
				groupUser: [userInfo]
			};
		}
		const res = await dbb.collection('Group').where({
			groupId: event.groupId
		}).update(updateData);

		const userdata = await dbb.collection('linli-user').where({
			userId: event.userId
		}).field({
			addedGroup: true
		}).get()
		let added;
		if (Array.isArray(addedGroup)) {
			added = {
				addedGroup: dbb.command.push(event.groupId)
			}
		} else {
			added = {
				addedGroup: [event.groupId]
			}
		}
		await dbb.collection('linli-user').where({
			userId: event.userId
		}).update(added)
		return true
	} catch (e) {
		console.error(e);
	}

}
//上线通知
async function onLineNotific(user, location) {

	try {
		const radius = Math.round(user.stateConfig.receiveDistance / 100);
		const result = await getNearbyInfo(location, radius);

		const notificMsg = {
			code: 0,
			type: "onLine",
			data: user
		};

		// 1. 过滤出在线用户的connectionId
		// 2. 用Set去重
		// 3. 转换回数组
		const toConnectionId = [...new Set(
			result.result.data
			.filter(item => item.isOnline)
			.map(item => item.connectionId)
		)];
		console.log(",,,,,,,,,,,,", toConnectionId);
		// 过滤掉空值（可选，根据实际数据情况）
		const validConnectionIds = toConnectionId.filter(id => id);

		if (validConnectionIds.length === 0) {
			console.log('在线人员通知人数', validConnectionIds.length);
			return;
		}

		if (validConnectionIds.length > 10) {
			const sendArr = splitArray(validConnectionIds);
			await Promise.all(sendArr.map(arr => ws.send(arr, JSON.stringify(notificMsg))));
		} else {
			await ws.send(validConnectionIds, JSON.stringify(notificMsg));
		}
	} catch (e) {
		console.error('处理上线通知出错', e);
	}
}

//转换地理格子
function getGridCode(location) {
	const lonPart = (Math.round(location.longitude * 1000) / 1000).toFixed(3);
	const latPart = (Math.round(location.latitude * 1000) / 1000).toFixed(3);
	return `${lonPart}_${latPart}`;
}
//获取范围格子
function getSurroundingGrids(centerGrid, radius) {
	const [lonStr, latStr] = centerGrid.split('_');
	let centerLon = parseFloat(lonStr);
	let centerLat = parseFloat(latStr);

	const grids = new Set();
	for (let x = -radius; x <= radius; x++) {
		for (let y = -radius; y <= radius; y++) {
			let targetLon = centerLon + x * 0.001;
			let targetLat = centerLat + y * 0.001;

			// 处理经度环绕
			if (targetLon < -180) targetLon += 360;
			else if (targetLon > 180) targetLon -= 360;

			// 处理纬度边界
			targetLat = Math.max(-90, Math.min(90, targetLat));
			const location = {
				longitude: targetLon,
				latitude: targetLat
			}

			grids.add(getGridCode(location));

		}
	}
	return Array.from(grids);
}


//获取周边用户及信息
async function getNearbyInfo(location, radius) {

	try {
		// 查询在线用户
		const dbb = uniCloud.database();
		const _ = dbb.command; // 数据库操作符（后续用于过滤）

		// 3. 生成网格编码：依赖自定义函数 getGridCode（需确保其逻辑正确，如基于 GeoHash/自定义网格）
		const centerGrid = getGridCode(location);
		if (!centerGrid) {
			throw new Error("网格编码生成失败：请检查 getGridCode 函数（如 location 格式是否正确）");
		}

		// 4. 获取周边网格：依赖自定义函数 getSurroundingGrids（生成 radius 范围内的所有网格编码）
		const surroundingGrids = getSurroundingGrids(centerGrid, radius);
	
		if (!Array.isArray(surroundingGrids) || surroundingGrids.length === 0) {
			throw new Error("周边网格生成失败：请检查 getSurroundingGrids 函数（如 radius 取值是否合理）");
		}

		// 5. 聚合查询：查询周边 POI + 关联用户信息（核心逻辑）
		const aggregateRes = await dbb.collection('opendb-poi') // 目标 POI 集合（需确认集合名正确）
			.aggregate()
			// 步骤1：筛选“周边网格内的 POI”（核心过滤条件，基于网格查询提升效率）
			.match({
				grid: _.in(surroundingGrids), // 只查目标网格内的数据
				// isDelete: _.neq(true) // 可选：过滤已删除的无效 POI（若集合有此字段）
			})
			// 步骤2：关联用户信息（从 linli-user 集合通过 userId 匹配）
			.lookup({
				from: "linli-user", // 关联的用户集合名（需确认正确）
				localField: "userId", // POI 集合中关联用户的字段（如“创建该 POI 的用户 ID”）
				foreignField: "userId", // 用户集合中对应的关联字段（需与 localField 一致）
				as: "userInfo" // 关联后的数据存储字段名（默认数组格式）
			})
			// // 步骤3：展开 userInfo 数组（1对1关联时，将数组转为对象，方便后续处理）
			.unwind({
				path: "$userInfo", // 展开的字段路径（需加 $ 符号）
				preserveNullAndEmptyArrays: false // 过滤掉 userInfo 为空的 POI（无关联用户的不返回）
			})
			// 步骤4：投影字段（只返回需要的字段，减少数据传输量）
			.project({
				_id: 1,
				userId: 1,
				type: 1,
				updateTime: 1,
				location: 1,
				connectionId:"$userInfo.connectionId",
				push_clientid:"$userInfo.push_clientid",
				// 拉平userInfo的字段到顶层（临时字段名：userNicName、userNicPic）
				nicName: "$userInfo.nicName", // 顶层临时字段：存储用户名
				nicPic: "$userInfo.nicPic", // 顶层临时字段：存储头像
				userInfo: 0 // 隐藏原始userInfo字段（可选，减少数据量）
			})
		
			
			.end();
		// 6. 检查聚合查询结果
		if (!aggregateRes.data || aggregateRes.data.length === 0) {
			throw new Error(`数据库查询失败：${aggregateRes.message || '未知错误'}`);
		}

		// 7. 返回成功结果（统一格式，方便前端处理）
		return {
			success: true,
			message: "附近信息查询成功",
			data: aggregateRes.data || [] // 具体的 POI+用户信息列表
			
		};

	} catch (error) {
		// 8. 统一错误处理（携带错误信息，方便前端排查）
		console.error("getNearbyInfo 函数执行失败：", error);
		return {
			success: false,
			message: error.message || "附近信息查询失败",
			errorCode: error.code || "QUERY_ERROR", // 错误码（前端可基于此做不同提示）
			data: []
		};
	}
}